#include <gtest/gtest.h>
#include "viml/builtin_list.h"
#include "viml/value.h"
#include <vector>

using namespace viml;

// 测试 len_builtin 函数
TEST(ListBuiltinsTest, LenFunction) {
    // 测试空列表
    std::vector<Value> empty_list_args = {Value::list()};
    Value result = len_builtin(empty_list_args);
    EXPECT_TRUE(result.is_number());
    EXPECT_EQ(result.as_number(), 0);
    
    // 测试非空列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(1));
    list.as_list().push_back(Value::make_number(2));
    list.as_list().push_back(Value::make_number(3));
    
    std::vector<Value> list_args = {list};
    result = len_builtin(list_args);
    EXPECT_TRUE(result.is_number());
    EXPECT_EQ(result.as_number(), 3);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> no_args = {};
    EXPECT_THROW(len_builtin(no_args), std::runtime_error);
    
    std::vector<Value> too_many_args = {Value::list(), Value::nil()};
    EXPECT_THROW(len_builtin(too_many_args), std::runtime_error);
}

// 测试 add_builtin 函数
TEST(ListBuiltinsTest, AddFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(1));
    list.as_list().push_back(Value::make_number(2));
    
    // 测试添加元素
    std::vector<Value> args = {list, Value::make_number(3)};
    Value result = add_builtin(args);
    
    // 检查返回值
    EXPECT_TRUE(result.is_list());
    EXPECT_EQ(result.as_list().size(), 3);
    EXPECT_EQ(result.as_list()[2].as_number(), 3);
    
    // 检查原列表已被修改
    EXPECT_EQ(list.as_list().size(), 3);
    EXPECT_EQ(list.as_list()[2].as_number(), 3);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {list};
    EXPECT_THROW(add_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1), Value::make_number(2)};
    EXPECT_THROW(add_builtin(invalid_args), std::runtime_error);
}

// 测试 insert_builtin 函数
TEST(ListBuiltinsTest, InsertFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(1));
    list.as_list().push_back(Value::make_number(3));
    
    // 测试在指定位置插入
    std::vector<Value> args2 = {list, Value::make_number(1), Value::make_number(2)};
    Value result2 = insert_builtin(args2);
    EXPECT_TRUE(result2.is_list());
    EXPECT_EQ(result2.as_list().size(), 3);
    EXPECT_EQ(result2.as_list()[1].as_number(), 2);
    EXPECT_EQ(list.as_list().size(), 3);
    EXPECT_EQ(list.as_list()[1].as_number(), 2);
    
    // 测试在开头插入
    Value list2 = Value::list();
    list2.as_list().push_back(Value::make_number(2));
    list2.as_list().push_back(Value::make_number(3));
    
    std::vector<Value> args1 = {list2, Value::make_number(0)};
    Value result1 = insert_builtin(args1);
    EXPECT_TRUE(result1.is_list());
    EXPECT_EQ(result1.as_list().size(), 3);
    EXPECT_EQ(result1.as_list()[0].as_number(), 0);
    EXPECT_EQ(list2.as_list().size(), 3);
    EXPECT_EQ(list2.as_list()[0].as_number(), 0);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {list};
    EXPECT_THROW(insert_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1), Value::make_number(2)};
    EXPECT_THROW(insert_builtin(invalid_args), std::runtime_error);
}

// 测试 remove_builtin 函数
TEST(ListBuiltinsTest, RemoveFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(1));
    list.as_list().push_back(Value::make_number(2));
    list.as_list().push_back(Value::make_number(3));
    
    // 测试移除单个元素
    std::vector<Value> args1 = {list, Value::make_number(1)};
    Value result1 = remove_builtin(args1);
    EXPECT_TRUE(result1.is_number());
    EXPECT_EQ(result1.as_number(), 2);
    
    // 测试移除范围元素
    Value list2 = Value::list();
    list2.as_list().push_back(Value::make_number(1));
    list2.as_list().push_back(Value::make_number(2));
    list2.as_list().push_back(Value::make_number(3));
    list2.as_list().push_back(Value::make_number(4));
    
    std::vector<Value> args2 = {list2, Value::make_number(1), Value::make_number(2)};
    Value result2 = remove_builtin(args2);
    EXPECT_TRUE(result2.is_list());
    EXPECT_EQ(result2.as_list().size(), 2);
    EXPECT_EQ(result2.as_list()[0].as_number(), 2);
    EXPECT_EQ(result2.as_list()[1].as_number(), 3);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {list};
    EXPECT_THROW(remove_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1), Value::make_number(2)};
    EXPECT_THROW(remove_builtin(invalid_args), std::runtime_error);
}

// 测试 index_builtin 函数
TEST(ListBuiltinsTest, IndexFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(10));
    list.as_list().push_back(Value::make_number(20));
    list.as_list().push_back(Value::make_number(30));
    
    // 测试找到元素
    std::vector<Value> args1 = {list, Value::make_number(20)};
    Value result1 = index_builtin(args1);
    EXPECT_TRUE(result1.is_number());
    EXPECT_EQ(result1.as_number(), 1);
    
    // 测试未找到元素
    std::vector<Value> args2 = {list, Value::make_number(40)};
    Value result2 = index_builtin(args2);
    std::cout << "Result2 type: " << static_cast<int>(result2.type()) << std::endl;
    std::cout << "Result2 debug string: " << result2.debug_string() << std::endl;
    EXPECT_TRUE(result2.is_number());
    EXPECT_EQ(result2.as_number(), -1);
    
    // 测试从指定位置开始查找
    std::vector<Value> args3 = {list, Value::make_number(10), Value::make_number(1)};
    Value result3 = index_builtin(args3);
    EXPECT_TRUE(result3.is_number());
    EXPECT_EQ(result3.as_number(), -1);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {};
    EXPECT_THROW(index_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1), Value::make_number(2)};
    EXPECT_THROW(index_builtin(invalid_args), std::runtime_error);
}

// 测试 count_builtin 函数
TEST(ListBuiltinsTest, CountFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(10));
    list.as_list().push_back(Value::make_number(20));
    list.as_list().push_back(Value::make_number(10));
    list.as_list().push_back(Value::make_number(30));
    list.as_list().push_back(Value::make_number(10));
    
    // 测试计数
    std::vector<Value> args = {list, Value::make_number(10)};
    Value result = count_builtin(args);
    EXPECT_TRUE(result.is_number());
    EXPECT_EQ(result.as_number(), 3);
    
    // 测试未找到元素
    std::vector<Value> args2 = {list, Value::make_number(40)};
    Value result2 = count_builtin(args2);
    EXPECT_TRUE(result2.is_number());
    EXPECT_EQ(result2.as_number(), 0);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {list};
    EXPECT_THROW(count_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1), Value::make_number(2)};
    EXPECT_THROW(count_builtin(invalid_args), std::runtime_error);
}

// 测试 reverse_builtin 函数
TEST(ListBuiltinsTest, ReverseFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(1));
    list.as_list().push_back(Value::make_number(2));
    list.as_list().push_back(Value::make_number(3));
    
    // 测试反转
    std::vector<Value> args = {list};
    Value result = reverse_builtin(args);
    EXPECT_TRUE(result.is_list());
    EXPECT_EQ(result.as_list().size(), 3);
    EXPECT_EQ(result.as_list()[0].as_number(), 3);
    EXPECT_EQ(result.as_list()[1].as_number(), 2);
    EXPECT_EQ(result.as_list()[2].as_number(), 1);
    
    // 检查原列表已被修改
    EXPECT_EQ(list.as_list()[0].as_number(), 3);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {};
    EXPECT_THROW(reverse_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1)};
    EXPECT_THROW(reverse_builtin(invalid_args), std::runtime_error);
}

// 测试 sort_builtin 函数
TEST(ListBuiltinsTest, SortFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(3));
    list.as_list().push_back(Value::make_number(1));
    list.as_list().push_back(Value::make_number(2));
    
    // 测试排序
    std::vector<Value> args = {list};
    Value result = sort_builtin(args);
    EXPECT_TRUE(result.is_list());
    EXPECT_EQ(result.as_list().size(), 3);
    EXPECT_EQ(result.as_list()[0].as_number(), 1);
    EXPECT_EQ(result.as_list()[1].as_number(), 2);
    EXPECT_EQ(result.as_list()[2].as_number(), 3);
    
    // 检查原列表已被修改
    EXPECT_EQ(list.as_list()[0].as_number(), 1);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {};
    EXPECT_THROW(sort_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1)};
    EXPECT_THROW(sort_builtin(invalid_args), std::runtime_error);
}

// 测试 copy_builtin 函数
TEST(ListBuiltinsTest, CopyFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(1));
    list.as_list().push_back(Value::make_number(2));
    
    // 测试浅拷贝
    std::vector<Value> args = {list};
    Value result = copy_builtin(args);
    EXPECT_TRUE(result.is_list());
    EXPECT_EQ(result.as_list().size(), 2);
    EXPECT_EQ(result.as_list()[0].as_number(), 1);
    EXPECT_EQ(result.as_list()[1].as_number(), 2);
    
    // 检查是浅拷贝（修改原列表不应影响拷贝）
    list.as_list()[0] = Value::make_number(10);
    EXPECT_EQ(result.as_list()[0].as_number(), 1);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {};
    EXPECT_THROW(copy_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1)};
    EXPECT_THROW(copy_builtin(invalid_args), std::runtime_error);
}

// 测试 deepcopy_builtin 函数
TEST(ListBuiltinsTest, DeepcopyFunction) {
    // 创建测试列表
    Value list = Value::list();
    list.as_list().push_back(Value::make_number(1));
    list.as_list().push_back(Value::make_number(2));
    
    // 测试深拷贝
    std::vector<Value> args = {list};
    Value result = deepcopy_builtin(args);
    EXPECT_TRUE(result.is_list());
    EXPECT_EQ(result.as_list().size(), 2);
    EXPECT_EQ(result.as_list()[0].as_number(), 1);
    EXPECT_EQ(result.as_list()[1].as_number(), 2);
    
    // 检查是深拷贝（修改原列表不应影响拷贝）
    list.as_list()[0] = Value::make_number(10);
    EXPECT_EQ(result.as_list()[0].as_number(), 1);
    
    // 测试错误情况 - 参数数量不正确
    std::vector<Value> wrong_args = {};
    EXPECT_THROW(deepcopy_builtin(wrong_args), std::runtime_error);
    
    // 测试错误情况 - 第一个参数不是列表
    std::vector<Value> invalid_args = {Value::make_number(1)};
    EXPECT_THROW(deepcopy_builtin(invalid_args), std::runtime_error);
}